// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.tmp.fba.inventory;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.TmpFbaInventory;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(TmpFbaInventory.class)
@Setter
@Getter
public class TmpFbaInventorySearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "TmpFbaInventory".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("warehouse", "w");
    map.put("productId", "p");
    map.put("head", "su");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 仓库
   */
  private Long warehouse;

  /**
   * 仓库 比较(eq)
   */
  private Long warehouseEq;
  /**
   * 仓库 比较(neq)
   */
  private Long warehouseNeq;
  /**
   * 仓库 比较(gt)
   */
  private Long warehouseGt;
  /**
   * 仓库 比较(gte)
   */
  private Long warehouseGte;
  /**
   * 仓库 比较(lt)
   */
  private Long warehouseLt;
  /**
   * 仓库 比较(lte)
   */
  private Long warehouseLte;
  /**
   * 仓库 比较(contains)
   */
  private Long warehouseContains;
  /**
   * 仓库 比较(notcontains)
   */
  private Long warehouseNotcontains;
  /**
   * 仓库 比较(startswith)
   */
  private Long warehouseStartswith;
  /**
   * 仓库 比较(endswith)
   */
  private Long warehouseEndswith;
  /**
   * 仓库 比较(isnull)
   */
  private Boolean warehouseIsnull;
  /**
   * 仓库 比较(isnotnull)
   */
  private Boolean warehouseIsnotnull;
  /**
   * 仓库的仓库名称 比较(eq)
   */
  private String warehouseNameEq;
  /**
   * 仓库的仓库名称 比较(neq)
   */
  private String warehouseNameNeq;
  /**
   * 仓库的仓库名称 比较(gt)
   */
  private String warehouseNameGt;
  /**
   * 仓库的仓库名称 比较(gte)
   */
  private String warehouseNameGte;
  /**
   * 仓库的仓库名称 比较(lt)
   */
  private String warehouseNameLt;
  /**
   * 仓库的仓库名称 比较(lte)
   */
  private String warehouseNameLte;
  /**
   * 仓库的仓库名称 比较(contains)
   */
  private String warehouseNameContains;
  /**
   * 仓库的仓库名称 比较(notcontains)
   */
  private String warehouseNameNotcontains;
  /**
   * 仓库的仓库名称 比较(startswith)
   */
  private String warehouseNameStartswith;
  /**
   * 仓库的仓库名称 比较(endswith)
   */
  private String warehouseNameEndswith;
  /**
   * 仓库的仓库名称 比较(isnull)
   */
  private Boolean warehouseNameIsnull;
  /**
   * 仓库的仓库名称 比较(isnotnull)
   */
  private Boolean warehouseNameIsnotnull;

  /**
   * 仓库(范围搜索)
   */
  private List<Long> warehouseInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 是否有 图片
   */
  private Boolean picture;

  /**
   * ASIN(模糊搜索)
   */
  private String asin;

  /**
   * ASIN 比较(eq)
   */
  private String asinEq;
  /**
   * ASIN 比较(neq)
   */
  private String asinNeq;
  /**
   * ASIN 比较(gt)
   */
  private String asinGt;
  /**
   * ASIN 比较(gte)
   */
  private String asinGte;
  /**
   * ASIN 比较(lt)
   */
  private String asinLt;
  /**
   * ASIN 比较(lte)
   */
  private String asinLte;
  /**
   * ASIN 比较(contains)
   */
  private String asinContains;
  /**
   * ASIN 比较(notcontains)
   */
  private String asinNotcontains;
  /**
   * ASIN 比较(startswith)
   */
  private String asinStartswith;
  /**
   * ASIN 比较(endswith)
   */
  private String asinEndswith;
  /**
   * ASIN 比较(isnull)
   */
  private Boolean asinIsnull;
  /**
   * ASIN 比较(isnotnull)
   */
  private Boolean asinIsnotnull;

  /**
   * ASIN(精确搜索)
   */
  private List<String> asinInList;

  /**
   * MSKU(模糊搜索)
   */
  private String msku;

  /**
   * MSKU 比较(eq)
   */
  private String mskuEq;
  /**
   * MSKU 比较(neq)
   */
  private String mskuNeq;
  /**
   * MSKU 比较(gt)
   */
  private String mskuGt;
  /**
   * MSKU 比较(gte)
   */
  private String mskuGte;
  /**
   * MSKU 比较(lt)
   */
  private String mskuLt;
  /**
   * MSKU 比较(lte)
   */
  private String mskuLte;
  /**
   * MSKU 比较(contains)
   */
  private String mskuContains;
  /**
   * MSKU 比较(notcontains)
   */
  private String mskuNotcontains;
  /**
   * MSKU 比较(startswith)
   */
  private String mskuStartswith;
  /**
   * MSKU 比较(endswith)
   */
  private String mskuEndswith;
  /**
   * MSKU 比较(isnull)
   */
  private Boolean mskuIsnull;
  /**
   * MSKU 比较(isnotnull)
   */
  private Boolean mskuIsnotnull;

  /**
   * MSKU(精确搜索)
   */
  private List<String> mskuInList;

  /**
   * FNSKU(模糊搜索)
   */
  private String fnsku;

  /**
   * FNSKU 比较(eq)
   */
  private String fnskuEq;
  /**
   * FNSKU 比较(neq)
   */
  private String fnskuNeq;
  /**
   * FNSKU 比较(gt)
   */
  private String fnskuGt;
  /**
   * FNSKU 比较(gte)
   */
  private String fnskuGte;
  /**
   * FNSKU 比较(lt)
   */
  private String fnskuLt;
  /**
   * FNSKU 比较(lte)
   */
  private String fnskuLte;
  /**
   * FNSKU 比较(contains)
   */
  private String fnskuContains;
  /**
   * FNSKU 比较(notcontains)
   */
  private String fnskuNotcontains;
  /**
   * FNSKU 比较(startswith)
   */
  private String fnskuStartswith;
  /**
   * FNSKU 比较(endswith)
   */
  private String fnskuEndswith;
  /**
   * FNSKU 比较(isnull)
   */
  private Boolean fnskuIsnull;
  /**
   * FNSKU 比较(isnotnull)
   */
  private Boolean fnskuIsnotnull;

  /**
   * FNSKU(精确搜索)
   */
  private List<String> fnskuInList;

  /**
   * 品名
   */
  private Long productId;

  /**
   * 品名 比较(eq)
   */
  private Long productIdEq;
  /**
   * 品名 比较(neq)
   */
  private Long productIdNeq;
  /**
   * 品名 比较(gt)
   */
  private Long productIdGt;
  /**
   * 品名 比较(gte)
   */
  private Long productIdGte;
  /**
   * 品名 比较(lt)
   */
  private Long productIdLt;
  /**
   * 品名 比较(lte)
   */
  private Long productIdLte;
  /**
   * 品名 比较(contains)
   */
  private Long productIdContains;
  /**
   * 品名 比较(notcontains)
   */
  private Long productIdNotcontains;
  /**
   * 品名 比较(startswith)
   */
  private Long productIdStartswith;
  /**
   * 品名 比较(endswith)
   */
  private Long productIdEndswith;
  /**
   * 品名 比较(isnull)
   */
  private Boolean productIdIsnull;
  /**
   * 品名 比较(isnotnull)
   */
  private Boolean productIdIsnotnull;
  /**
   * 品名的品名 比较(eq)
   */
  private String productIdNameEq;
  /**
   * 品名的品名 比较(neq)
   */
  private String productIdNameNeq;
  /**
   * 品名的品名 比较(gt)
   */
  private String productIdNameGt;
  /**
   * 品名的品名 比较(gte)
   */
  private String productIdNameGte;
  /**
   * 品名的品名 比较(lt)
   */
  private String productIdNameLt;
  /**
   * 品名的品名 比较(lte)
   */
  private String productIdNameLte;
  /**
   * 品名的品名 比较(contains)
   */
  private String productIdNameContains;
  /**
   * 品名的品名 比较(notcontains)
   */
  private String productIdNameNotcontains;
  /**
   * 品名的品名 比较(startswith)
   */
  private String productIdNameStartswith;
  /**
   * 品名的品名 比较(endswith)
   */
  private String productIdNameEndswith;
  /**
   * 品名的品名 比较(isnull)
   */
  private Boolean productIdNameIsnull;
  /**
   * 品名的品名 比较(isnotnull)
   */
  private Boolean productIdNameIsnotnull;

  /**
   * 品名(范围搜索)
   */
  private List<Long> productIdInList;

  /**
   * SKU(模糊搜索)
   */
  private String sku;

  /**
   * SKU 比较(eq)
   */
  private String skuEq;
  /**
   * SKU 比较(neq)
   */
  private String skuNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuGt;
  /**
   * SKU 比较(gte)
   */
  private String skuGte;
  /**
   * SKU 比较(lt)
   */
  private String skuLt;
  /**
   * SKU 比较(lte)
   */
  private String skuLte;
  /**
   * SKU 比较(contains)
   */
  private String skuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuInList;

  /**
   * 负责人
   */
  private Long head;

  /**
   * 负责人 比较(eq)
   */
  private Long headEq;
  /**
   * 负责人 比较(neq)
   */
  private Long headNeq;
  /**
   * 负责人 比较(gt)
   */
  private Long headGt;
  /**
   * 负责人 比较(gte)
   */
  private Long headGte;
  /**
   * 负责人 比较(lt)
   */
  private Long headLt;
  /**
   * 负责人 比较(lte)
   */
  private Long headLte;
  /**
   * 负责人 比较(contains)
   */
  private Long headContains;
  /**
   * 负责人 比较(notcontains)
   */
  private Long headNotcontains;
  /**
   * 负责人 比较(startswith)
   */
  private Long headStartswith;
  /**
   * 负责人 比较(endswith)
   */
  private Long headEndswith;
  /**
   * 负责人 比较(isnull)
   */
  private Boolean headIsnull;
  /**
   * 负责人 比较(isnotnull)
   */
  private Boolean headIsnotnull;
  /**
   * 负责人的显示用户名 比较(eq)
   */
  private String headNameEq;
  /**
   * 负责人的显示用户名 比较(neq)
   */
  private String headNameNeq;
  /**
   * 负责人的显示用户名 比较(gt)
   */
  private String headNameGt;
  /**
   * 负责人的显示用户名 比较(gte)
   */
  private String headNameGte;
  /**
   * 负责人的显示用户名 比较(lt)
   */
  private String headNameLt;
  /**
   * 负责人的显示用户名 比较(lte)
   */
  private String headNameLte;
  /**
   * 负责人的显示用户名 比较(contains)
   */
  private String headNameContains;
  /**
   * 负责人的显示用户名 比较(notcontains)
   */
  private String headNameNotcontains;
  /**
   * 负责人的显示用户名 比较(startswith)
   */
  private String headNameStartswith;
  /**
   * 负责人的显示用户名 比较(endswith)
   */
  private String headNameEndswith;
  /**
   * 负责人的显示用户名 比较(isnull)
   */
  private Boolean headNameIsnull;
  /**
   * 负责人的显示用户名 比较(isnotnull)
   */
  private Boolean headNameIsnotnull;

  /**
   * 负责人(范围搜索)
   */
  private List<Long> headInList;

  /**
   * 总库存
   */
  private Integer totalInventory;

  /**
   * 最小总库存
   */
  private Integer totalInventoryMin;

  /**
   * 最大总库存
   */
  private Integer totalInventoryMax;

  /**
   * 总库存 比较(eq)
   */
  private Integer totalInventoryEq;
  /**
   * 总库存 比较(neq)
   */
  private Integer totalInventoryNeq;
  /**
   * 总库存 比较(gt)
   */
  private Integer totalInventoryGt;
  /**
   * 总库存 比较(gte)
   */
  private Integer totalInventoryGte;
  /**
   * 总库存 比较(lt)
   */
  private Integer totalInventoryLt;
  /**
   * 总库存 比较(lte)
   */
  private Integer totalInventoryLte;
  /**
   * 总库存 比较(contains)
   */
  private Integer totalInventoryContains;
  /**
   * 总库存 比较(notcontains)
   */
  private Integer totalInventoryNotcontains;
  /**
   * 总库存 比较(startswith)
   */
  private Integer totalInventoryStartswith;
  /**
   * 总库存 比较(endswith)
   */
  private Integer totalInventoryEndswith;
  /**
   * 总库存 比较(isnull)
   */
  private Boolean totalInventoryIsnull;
  /**
   * 总库存 比较(isnotnull)
   */
  private Boolean totalInventoryIsnotnull;

  /**
   * 可用库存
   */
  private Integer availableStock;

  /**
   * 最小可用库存
   */
  private Integer availableStockMin;

  /**
   * 最大可用库存
   */
  private Integer availableStockMax;

  /**
   * 可用库存 比较(eq)
   */
  private Integer availableStockEq;
  /**
   * 可用库存 比较(neq)
   */
  private Integer availableStockNeq;
  /**
   * 可用库存 比较(gt)
   */
  private Integer availableStockGt;
  /**
   * 可用库存 比较(gte)
   */
  private Integer availableStockGte;
  /**
   * 可用库存 比较(lt)
   */
  private Integer availableStockLt;
  /**
   * 可用库存 比较(lte)
   */
  private Integer availableStockLte;
  /**
   * 可用库存 比较(contains)
   */
  private Integer availableStockContains;
  /**
   * 可用库存 比较(notcontains)
   */
  private Integer availableStockNotcontains;
  /**
   * 可用库存 比较(startswith)
   */
  private Integer availableStockStartswith;
  /**
   * 可用库存 比较(endswith)
   */
  private Integer availableStockEndswith;
  /**
   * 可用库存 比较(isnull)
   */
  private Boolean availableStockIsnull;
  /**
   * 可用库存 比较(isnotnull)
   */
  private Boolean availableStockIsnotnull;

  /**
   * FBA可售
   */
  private Integer fbaAvailableForSale;

  /**
   * 最小FBA可售
   */
  private Integer fbaAvailableForSaleMin;

  /**
   * 最大FBA可售
   */
  private Integer fbaAvailableForSaleMax;

  /**
   * FBA可售 比较(eq)
   */
  private Integer fbaAvailableForSaleEq;
  /**
   * FBA可售 比较(neq)
   */
  private Integer fbaAvailableForSaleNeq;
  /**
   * FBA可售 比较(gt)
   */
  private Integer fbaAvailableForSaleGt;
  /**
   * FBA可售 比较(gte)
   */
  private Integer fbaAvailableForSaleGte;
  /**
   * FBA可售 比较(lt)
   */
  private Integer fbaAvailableForSaleLt;
  /**
   * FBA可售 比较(lte)
   */
  private Integer fbaAvailableForSaleLte;
  /**
   * FBA可售 比较(contains)
   */
  private Integer fbaAvailableForSaleContains;
  /**
   * FBA可售 比较(notcontains)
   */
  private Integer fbaAvailableForSaleNotcontains;
  /**
   * FBA可售 比较(startswith)
   */
  private Integer fbaAvailableForSaleStartswith;
  /**
   * FBA可售 比较(endswith)
   */
  private Integer fbaAvailableForSaleEndswith;
  /**
   * FBA可售 比较(isnull)
   */
  private Boolean fbaAvailableForSaleIsnull;
  /**
   * FBA可售 比较(isnotnull)
   */
  private Boolean fbaAvailableForSaleIsnotnull;

  /**
   * FBM可售
   */
  private Integer fbmAvailableForSale;

  /**
   * 最小FBM可售
   */
  private Integer fbmAvailableForSaleMin;

  /**
   * 最大FBM可售
   */
  private Integer fbmAvailableForSaleMax;

  /**
   * FBM可售 比较(eq)
   */
  private Integer fbmAvailableForSaleEq;
  /**
   * FBM可售 比较(neq)
   */
  private Integer fbmAvailableForSaleNeq;
  /**
   * FBM可售 比较(gt)
   */
  private Integer fbmAvailableForSaleGt;
  /**
   * FBM可售 比较(gte)
   */
  private Integer fbmAvailableForSaleGte;
  /**
   * FBM可售 比较(lt)
   */
  private Integer fbmAvailableForSaleLt;
  /**
   * FBM可售 比较(lte)
   */
  private Integer fbmAvailableForSaleLte;
  /**
   * FBM可售 比较(contains)
   */
  private Integer fbmAvailableForSaleContains;
  /**
   * FBM可售 比较(notcontains)
   */
  private Integer fbmAvailableForSaleNotcontains;
  /**
   * FBM可售 比较(startswith)
   */
  private Integer fbmAvailableForSaleStartswith;
  /**
   * FBM可售 比较(endswith)
   */
  private Integer fbmAvailableForSaleEndswith;
  /**
   * FBM可售 比较(isnull)
   */
  private Boolean fbmAvailableForSaleIsnull;
  /**
   * FBM可售 比较(isnotnull)
   */
  private Boolean fbmAvailableForSaleIsnotnull;

  /**
   * 待调仓
   */
  private Integer warehouseToBeAdjusted;

  /**
   * 最小待调仓
   */
  private Integer warehouseToBeAdjustedMin;

  /**
   * 最大待调仓
   */
  private Integer warehouseToBeAdjustedMax;

  /**
   * 待调仓 比较(eq)
   */
  private Integer warehouseToBeAdjustedEq;
  /**
   * 待调仓 比较(neq)
   */
  private Integer warehouseToBeAdjustedNeq;
  /**
   * 待调仓 比较(gt)
   */
  private Integer warehouseToBeAdjustedGt;
  /**
   * 待调仓 比较(gte)
   */
  private Integer warehouseToBeAdjustedGte;
  /**
   * 待调仓 比较(lt)
   */
  private Integer warehouseToBeAdjustedLt;
  /**
   * 待调仓 比较(lte)
   */
  private Integer warehouseToBeAdjustedLte;
  /**
   * 待调仓 比较(contains)
   */
  private Integer warehouseToBeAdjustedContains;
  /**
   * 待调仓 比较(notcontains)
   */
  private Integer warehouseToBeAdjustedNotcontains;
  /**
   * 待调仓 比较(startswith)
   */
  private Integer warehouseToBeAdjustedStartswith;
  /**
   * 待调仓 比较(endswith)
   */
  private Integer warehouseToBeAdjustedEndswith;
  /**
   * 待调仓 比较(isnull)
   */
  private Boolean warehouseToBeAdjustedIsnull;
  /**
   * 待调仓 比较(isnotnull)
   */
  private Boolean warehouseToBeAdjustedIsnotnull;

  /**
   * 调仓中
   */
  private Integer duringWarehouseAdjustment;

  /**
   * 最小调仓中
   */
  private Integer duringWarehouseAdjustmentMin;

  /**
   * 最大调仓中
   */
  private Integer duringWarehouseAdjustmentMax;

  /**
   * 调仓中 比较(eq)
   */
  private Integer duringWarehouseAdjustmentEq;
  /**
   * 调仓中 比较(neq)
   */
  private Integer duringWarehouseAdjustmentNeq;
  /**
   * 调仓中 比较(gt)
   */
  private Integer duringWarehouseAdjustmentGt;
  /**
   * 调仓中 比较(gte)
   */
  private Integer duringWarehouseAdjustmentGte;
  /**
   * 调仓中 比较(lt)
   */
  private Integer duringWarehouseAdjustmentLt;
  /**
   * 调仓中 比较(lte)
   */
  private Integer duringWarehouseAdjustmentLte;
  /**
   * 调仓中 比较(contains)
   */
  private Integer duringWarehouseAdjustmentContains;
  /**
   * 调仓中 比较(notcontains)
   */
  private Integer duringWarehouseAdjustmentNotcontains;
  /**
   * 调仓中 比较(startswith)
   */
  private Integer duringWarehouseAdjustmentStartswith;
  /**
   * 调仓中 比较(endswith)
   */
  private Integer duringWarehouseAdjustmentEndswith;
  /**
   * 调仓中 比较(isnull)
   */
  private Boolean duringWarehouseAdjustmentIsnull;
  /**
   * 调仓中 比较(isnotnull)
   */
  private Boolean duringWarehouseAdjustmentIsnotnull;

  /**
   * 待发货
   */
  private Integer toBeShipped;

  /**
   * 最小待发货
   */
  private Integer toBeShippedMin;

  /**
   * 最大待发货
   */
  private Integer toBeShippedMax;

  /**
   * 待发货 比较(eq)
   */
  private Integer toBeShippedEq;
  /**
   * 待发货 比较(neq)
   */
  private Integer toBeShippedNeq;
  /**
   * 待发货 比较(gt)
   */
  private Integer toBeShippedGt;
  /**
   * 待发货 比较(gte)
   */
  private Integer toBeShippedGte;
  /**
   * 待发货 比较(lt)
   */
  private Integer toBeShippedLt;
  /**
   * 待发货 比较(lte)
   */
  private Integer toBeShippedLte;
  /**
   * 待发货 比较(contains)
   */
  private Integer toBeShippedContains;
  /**
   * 待发货 比较(notcontains)
   */
  private Integer toBeShippedNotcontains;
  /**
   * 待发货 比较(startswith)
   */
  private Integer toBeShippedStartswith;
  /**
   * 待发货 比较(endswith)
   */
  private Integer toBeShippedEndswith;
  /**
   * 待发货 比较(isnull)
   */
  private Boolean toBeShippedIsnull;
  /**
   * 待发货 比较(isnotnull)
   */
  private Boolean toBeShippedIsnotnull;

  /**
   * 计划入库
   */
  private Integer plannedWarehousing;

  /**
   * 最小计划入库
   */
  private Integer plannedWarehousingMin;

  /**
   * 最大计划入库
   */
  private Integer plannedWarehousingMax;

  /**
   * 计划入库 比较(eq)
   */
  private Integer plannedWarehousingEq;
  /**
   * 计划入库 比较(neq)
   */
  private Integer plannedWarehousingNeq;
  /**
   * 计划入库 比较(gt)
   */
  private Integer plannedWarehousingGt;
  /**
   * 计划入库 比较(gte)
   */
  private Integer plannedWarehousingGte;
  /**
   * 计划入库 比较(lt)
   */
  private Integer plannedWarehousingLt;
  /**
   * 计划入库 比较(lte)
   */
  private Integer plannedWarehousingLte;
  /**
   * 计划入库 比较(contains)
   */
  private Integer plannedWarehousingContains;
  /**
   * 计划入库 比较(notcontains)
   */
  private Integer plannedWarehousingNotcontains;
  /**
   * 计划入库 比较(startswith)
   */
  private Integer plannedWarehousingStartswith;
  /**
   * 计划入库 比较(endswith)
   */
  private Integer plannedWarehousingEndswith;
  /**
   * 计划入库 比较(isnull)
   */
  private Boolean plannedWarehousingIsnull;
  /**
   * 计划入库 比较(isnotnull)
   */
  private Boolean plannedWarehousingIsnotnull;

  /**
   * 标发在途
   */
  private Integer standardInTransit;

  /**
   * 最小标发在途
   */
  private Integer standardInTransitMin;

  /**
   * 最大标发在途
   */
  private Integer standardInTransitMax;

  /**
   * 标发在途 比较(eq)
   */
  private Integer standardInTransitEq;
  /**
   * 标发在途 比较(neq)
   */
  private Integer standardInTransitNeq;
  /**
   * 标发在途 比较(gt)
   */
  private Integer standardInTransitGt;
  /**
   * 标发在途 比较(gte)
   */
  private Integer standardInTransitGte;
  /**
   * 标发在途 比较(lt)
   */
  private Integer standardInTransitLt;
  /**
   * 标发在途 比较(lte)
   */
  private Integer standardInTransitLte;
  /**
   * 标发在途 比较(contains)
   */
  private Integer standardInTransitContains;
  /**
   * 标发在途 比较(notcontains)
   */
  private Integer standardInTransitNotcontains;
  /**
   * 标发在途 比较(startswith)
   */
  private Integer standardInTransitStartswith;
  /**
   * 标发在途 比较(endswith)
   */
  private Integer standardInTransitEndswith;
  /**
   * 标发在途 比较(isnull)
   */
  private Boolean standardInTransitIsnull;
  /**
   * 标发在途 比较(isnotnull)
   */
  private Boolean standardInTransitIsnotnull;

  /**
   * 实际在途
   */
  private Integer actualInTransit;

  /**
   * 最小实际在途
   */
  private Integer actualInTransitMin;

  /**
   * 最大实际在途
   */
  private Integer actualInTransitMax;

  /**
   * 实际在途 比较(eq)
   */
  private Integer actualInTransitEq;
  /**
   * 实际在途 比较(neq)
   */
  private Integer actualInTransitNeq;
  /**
   * 实际在途 比较(gt)
   */
  private Integer actualInTransitGt;
  /**
   * 实际在途 比较(gte)
   */
  private Integer actualInTransitGte;
  /**
   * 实际在途 比较(lt)
   */
  private Integer actualInTransitLt;
  /**
   * 实际在途 比较(lte)
   */
  private Integer actualInTransitLte;
  /**
   * 实际在途 比较(contains)
   */
  private Integer actualInTransitContains;
  /**
   * 实际在途 比较(notcontains)
   */
  private Integer actualInTransitNotcontains;
  /**
   * 实际在途 比较(startswith)
   */
  private Integer actualInTransitStartswith;
  /**
   * 实际在途 比较(endswith)
   */
  private Integer actualInTransitEndswith;
  /**
   * 实际在途 比较(isnull)
   */
  private Boolean actualInTransitIsnull;
  /**
   * 实际在途 比较(isnotnull)
   */
  private Boolean actualInTransitIsnotnull;

  /**
   * 入库中
   */
  private Integer inStorage;

  /**
   * 最小入库中
   */
  private Integer inStorageMin;

  /**
   * 最大入库中
   */
  private Integer inStorageMax;

  /**
   * 入库中 比较(eq)
   */
  private Integer inStorageEq;
  /**
   * 入库中 比较(neq)
   */
  private Integer inStorageNeq;
  /**
   * 入库中 比较(gt)
   */
  private Integer inStorageGt;
  /**
   * 入库中 比较(gte)
   */
  private Integer inStorageGte;
  /**
   * 入库中 比较(lt)
   */
  private Integer inStorageLt;
  /**
   * 入库中 比较(lte)
   */
  private Integer inStorageLte;
  /**
   * 入库中 比较(contains)
   */
  private Integer inStorageContains;
  /**
   * 入库中 比较(notcontains)
   */
  private Integer inStorageNotcontains;
  /**
   * 入库中 比较(startswith)
   */
  private Integer inStorageStartswith;
  /**
   * 入库中 比较(endswith)
   */
  private Integer inStorageEndswith;
  /**
   * 入库中 比较(isnull)
   */
  private Boolean inStorageIsnull;
  /**
   * 入库中 比较(isnotnull)
   */
  private Boolean inStorageIsnotnull;

  /**
   * 不可售
   */
  private Integer notAvailableForSale;

  /**
   * 最小不可售
   */
  private Integer notAvailableForSaleMin;

  /**
   * 最大不可售
   */
  private Integer notAvailableForSaleMax;

  /**
   * 不可售 比较(eq)
   */
  private Integer notAvailableForSaleEq;
  /**
   * 不可售 比较(neq)
   */
  private Integer notAvailableForSaleNeq;
  /**
   * 不可售 比较(gt)
   */
  private Integer notAvailableForSaleGt;
  /**
   * 不可售 比较(gte)
   */
  private Integer notAvailableForSaleGte;
  /**
   * 不可售 比较(lt)
   */
  private Integer notAvailableForSaleLt;
  /**
   * 不可售 比较(lte)
   */
  private Integer notAvailableForSaleLte;
  /**
   * 不可售 比较(contains)
   */
  private Integer notAvailableForSaleContains;
  /**
   * 不可售 比较(notcontains)
   */
  private Integer notAvailableForSaleNotcontains;
  /**
   * 不可售 比较(startswith)
   */
  private Integer notAvailableForSaleStartswith;
  /**
   * 不可售 比较(endswith)
   */
  private Integer notAvailableForSaleEndswith;
  /**
   * 不可售 比较(isnull)
   */
  private Boolean notAvailableForSaleIsnull;
  /**
   * 不可售 比较(isnotnull)
   */
  private Boolean notAvailableForSaleIsnotnull;

  /**
   * 调查中
   */
  private Integer underInvestigation;

  /**
   * 最小调查中
   */
  private Integer underInvestigationMin;

  /**
   * 最大调查中
   */
  private Integer underInvestigationMax;

  /**
   * 调查中 比较(eq)
   */
  private Integer underInvestigationEq;
  /**
   * 调查中 比较(neq)
   */
  private Integer underInvestigationNeq;
  /**
   * 调查中 比较(gt)
   */
  private Integer underInvestigationGt;
  /**
   * 调查中 比较(gte)
   */
  private Integer underInvestigationGte;
  /**
   * 调查中 比较(lt)
   */
  private Integer underInvestigationLt;
  /**
   * 调查中 比较(lte)
   */
  private Integer underInvestigationLte;
  /**
   * 调查中 比较(contains)
   */
  private Integer underInvestigationContains;
  /**
   * 调查中 比较(notcontains)
   */
  private Integer underInvestigationNotcontains;
  /**
   * 调查中 比较(startswith)
   */
  private Integer underInvestigationStartswith;
  /**
   * 调查中 比较(endswith)
   */
  private Integer underInvestigationEndswith;
  /**
   * 调查中 比较(isnull)
   */
  private Boolean underInvestigationIsnull;
  /**
   * 调查中 比较(isnotnull)
   */
  private Boolean underInvestigationIsnotnull;

  /**
   * 预警状态
   */
  private String warningStatus;

  /**
   * 预警状态 比较(eq)
   */
  private String warningStatusEq;
  /**
   * 预警状态 比较(neq)
   */
  private String warningStatusNeq;
  /**
   * 预警状态 比较(gt)
   */
  private String warningStatusGt;
  /**
   * 预警状态 比较(gte)
   */
  private String warningStatusGte;
  /**
   * 预警状态 比较(lt)
   */
  private String warningStatusLt;
  /**
   * 预警状态 比较(lte)
   */
  private String warningStatusLte;
  /**
   * 预警状态 比较(contains)
   */
  private String warningStatusContains;
  /**
   * 预警状态 比较(notcontains)
   */
  private String warningStatusNotcontains;
  /**
   * 预警状态 比较(startswith)
   */
  private String warningStatusStartswith;
  /**
   * 预警状态 比较(endswith)
   */
  private String warningStatusEndswith;
  /**
   * 预警状态 比较(isnull)
   */
  private Boolean warningStatusIsnull;
  /**
   * 预警状态 比较(isnotnull)
   */
  private Boolean warningStatusIsnotnull;

  /**
   * 预警状态(精确搜索)
   */
  private List<String> warningStatusInList;

  /**
   * 0-30天库龄
   */
  private Integer day30;

  /**
   * 最小0-30天库龄
   */
  private Integer day30Min;

  /**
   * 最大0-30天库龄
   */
  private Integer day30Max;

  /**
   * 0-30天库龄 比较(eq)
   */
  private Integer day30Eq;
  /**
   * 0-30天库龄 比较(neq)
   */
  private Integer day30Neq;
  /**
   * 0-30天库龄 比较(gt)
   */
  private Integer day30Gt;
  /**
   * 0-30天库龄 比较(gte)
   */
  private Integer day30Gte;
  /**
   * 0-30天库龄 比较(lt)
   */
  private Integer day30Lt;
  /**
   * 0-30天库龄 比较(lte)
   */
  private Integer day30Lte;
  /**
   * 0-30天库龄 比较(contains)
   */
  private Integer day30Contains;
  /**
   * 0-30天库龄 比较(notcontains)
   */
  private Integer day30Notcontains;
  /**
   * 0-30天库龄 比较(startswith)
   */
  private Integer day30Startswith;
  /**
   * 0-30天库龄 比较(endswith)
   */
  private Integer day30Endswith;
  /**
   * 0-30天库龄 比较(isnull)
   */
  private Boolean day30Isnull;
  /**
   * 0-30天库龄 比较(isnotnull)
   */
  private Boolean day30Isnotnull;

  /**
   * 31-60天库龄
   */
  private Integer day60;

  /**
   * 最小31-60天库龄
   */
  private Integer day60Min;

  /**
   * 最大31-60天库龄
   */
  private Integer day60Max;

  /**
   * 31-60天库龄 比较(eq)
   */
  private Integer day60Eq;
  /**
   * 31-60天库龄 比较(neq)
   */
  private Integer day60Neq;
  /**
   * 31-60天库龄 比较(gt)
   */
  private Integer day60Gt;
  /**
   * 31-60天库龄 比较(gte)
   */
  private Integer day60Gte;
  /**
   * 31-60天库龄 比较(lt)
   */
  private Integer day60Lt;
  /**
   * 31-60天库龄 比较(lte)
   */
  private Integer day60Lte;
  /**
   * 31-60天库龄 比较(contains)
   */
  private Integer day60Contains;
  /**
   * 31-60天库龄 比较(notcontains)
   */
  private Integer day60Notcontains;
  /**
   * 31-60天库龄 比较(startswith)
   */
  private Integer day60Startswith;
  /**
   * 31-60天库龄 比较(endswith)
   */
  private Integer day60Endswith;
  /**
   * 31-60天库龄 比较(isnull)
   */
  private Boolean day60Isnull;
  /**
   * 31-60天库龄 比较(isnotnull)
   */
  private Boolean day60Isnotnull;

  /**
   * 61-90天库龄
   */
  private Integer day90;

  /**
   * 最小61-90天库龄
   */
  private Integer day90Min;

  /**
   * 最大61-90天库龄
   */
  private Integer day90Max;

  /**
   * 61-90天库龄 比较(eq)
   */
  private Integer day90Eq;
  /**
   * 61-90天库龄 比较(neq)
   */
  private Integer day90Neq;
  /**
   * 61-90天库龄 比较(gt)
   */
  private Integer day90Gt;
  /**
   * 61-90天库龄 比较(gte)
   */
  private Integer day90Gte;
  /**
   * 61-90天库龄 比较(lt)
   */
  private Integer day90Lt;
  /**
   * 61-90天库龄 比较(lte)
   */
  private Integer day90Lte;
  /**
   * 61-90天库龄 比较(contains)
   */
  private Integer day90Contains;
  /**
   * 61-90天库龄 比较(notcontains)
   */
  private Integer day90Notcontains;
  /**
   * 61-90天库龄 比较(startswith)
   */
  private Integer day90Startswith;
  /**
   * 61-90天库龄 比较(endswith)
   */
  private Integer day90Endswith;
  /**
   * 61-90天库龄 比较(isnull)
   */
  private Boolean day90Isnull;
  /**
   * 61-90天库龄 比较(isnotnull)
   */
  private Boolean day90Isnotnull;

  /**
   * 91-180天库龄
   */
  private Integer day180;

  /**
   * 最小91-180天库龄
   */
  private Integer day180Min;

  /**
   * 最大91-180天库龄
   */
  private Integer day180Max;

  /**
   * 91-180天库龄 比较(eq)
   */
  private Integer day180Eq;
  /**
   * 91-180天库龄 比较(neq)
   */
  private Integer day180Neq;
  /**
   * 91-180天库龄 比较(gt)
   */
  private Integer day180Gt;
  /**
   * 91-180天库龄 比较(gte)
   */
  private Integer day180Gte;
  /**
   * 91-180天库龄 比较(lt)
   */
  private Integer day180Lt;
  /**
   * 91-180天库龄 比较(lte)
   */
  private Integer day180Lte;
  /**
   * 91-180天库龄 比较(contains)
   */
  private Integer day180Contains;
  /**
   * 91-180天库龄 比较(notcontains)
   */
  private Integer day180Notcontains;
  /**
   * 91-180天库龄 比较(startswith)
   */
  private Integer day180Startswith;
  /**
   * 91-180天库龄 比较(endswith)
   */
  private Integer day180Endswith;
  /**
   * 91-180天库龄 比较(isnull)
   */
  private Boolean day180Isnull;
  /**
   * 91-180天库龄 比较(isnotnull)
   */
  private Boolean day180Isnotnull;

  /**
   * 181-270天库龄
   */
  private Integer day270;

  /**
   * 最小181-270天库龄
   */
  private Integer day270Min;

  /**
   * 最大181-270天库龄
   */
  private Integer day270Max;

  /**
   * 181-270天库龄 比较(eq)
   */
  private Integer day270Eq;
  /**
   * 181-270天库龄 比较(neq)
   */
  private Integer day270Neq;
  /**
   * 181-270天库龄 比较(gt)
   */
  private Integer day270Gt;
  /**
   * 181-270天库龄 比较(gte)
   */
  private Integer day270Gte;
  /**
   * 181-270天库龄 比较(lt)
   */
  private Integer day270Lt;
  /**
   * 181-270天库龄 比较(lte)
   */
  private Integer day270Lte;
  /**
   * 181-270天库龄 比较(contains)
   */
  private Integer day270Contains;
  /**
   * 181-270天库龄 比较(notcontains)
   */
  private Integer day270Notcontains;
  /**
   * 181-270天库龄 比较(startswith)
   */
  private Integer day270Startswith;
  /**
   * 181-270天库龄 比较(endswith)
   */
  private Integer day270Endswith;
  /**
   * 181-270天库龄 比较(isnull)
   */
  private Boolean day270Isnull;
  /**
   * 181-270天库龄 比较(isnotnull)
   */
  private Boolean day270Isnotnull;

  /**
   * 271-330天库龄
   */
  private Integer day330;

  /**
   * 最小271-330天库龄
   */
  private Integer day330Min;

  /**
   * 最大271-330天库龄
   */
  private Integer day330Max;

  /**
   * 271-330天库龄 比较(eq)
   */
  private Integer day330Eq;
  /**
   * 271-330天库龄 比较(neq)
   */
  private Integer day330Neq;
  /**
   * 271-330天库龄 比较(gt)
   */
  private Integer day330Gt;
  /**
   * 271-330天库龄 比较(gte)
   */
  private Integer day330Gte;
  /**
   * 271-330天库龄 比较(lt)
   */
  private Integer day330Lt;
  /**
   * 271-330天库龄 比较(lte)
   */
  private Integer day330Lte;
  /**
   * 271-330天库龄 比较(contains)
   */
  private Integer day330Contains;
  /**
   * 271-330天库龄 比较(notcontains)
   */
  private Integer day330Notcontains;
  /**
   * 271-330天库龄 比较(startswith)
   */
  private Integer day330Startswith;
  /**
   * 271-330天库龄 比较(endswith)
   */
  private Integer day330Endswith;
  /**
   * 271-330天库龄 比较(isnull)
   */
  private Boolean day330Isnull;
  /**
   * 271-330天库龄 比较(isnotnull)
   */
  private Boolean day330Isnotnull;

  /**
   * 331-365天库龄
   */
  private Integer day365;

  /**
   * 最小331-365天库龄
   */
  private Integer day365Min;

  /**
   * 最大331-365天库龄
   */
  private Integer day365Max;

  /**
   * 331-365天库龄 比较(eq)
   */
  private Integer day365Eq;
  /**
   * 331-365天库龄 比较(neq)
   */
  private Integer day365Neq;
  /**
   * 331-365天库龄 比较(gt)
   */
  private Integer day365Gt;
  /**
   * 331-365天库龄 比较(gte)
   */
  private Integer day365Gte;
  /**
   * 331-365天库龄 比较(lt)
   */
  private Integer day365Lt;
  /**
   * 331-365天库龄 比较(lte)
   */
  private Integer day365Lte;
  /**
   * 331-365天库龄 比较(contains)
   */
  private Integer day365Contains;
  /**
   * 331-365天库龄 比较(notcontains)
   */
  private Integer day365Notcontains;
  /**
   * 331-365天库龄 比较(startswith)
   */
  private Integer day365Startswith;
  /**
   * 331-365天库龄 比较(endswith)
   */
  private Integer day365Endswith;
  /**
   * 331-365天库龄 比较(isnull)
   */
  private Boolean day365Isnull;
  /**
   * 331-365天库龄 比较(isnotnull)
   */
  private Boolean day365Isnotnull;

  /**
   * 365天以上库龄
   */
  private Integer day366;

  /**
   * 最小365天以上库龄
   */
  private Integer day366Min;

  /**
   * 最大365天以上库龄
   */
  private Integer day366Max;

  /**
   * 365天以上库龄 比较(eq)
   */
  private Integer day366Eq;
  /**
   * 365天以上库龄 比较(neq)
   */
  private Integer day366Neq;
  /**
   * 365天以上库龄 比较(gt)
   */
  private Integer day366Gt;
  /**
   * 365天以上库龄 比较(gte)
   */
  private Integer day366Gte;
  /**
   * 365天以上库龄 比较(lt)
   */
  private Integer day366Lt;
  /**
   * 365天以上库龄 比较(lte)
   */
  private Integer day366Lte;
  /**
   * 365天以上库龄 比较(contains)
   */
  private Integer day366Contains;
  /**
   * 365天以上库龄 比较(notcontains)
   */
  private Integer day366Notcontains;
  /**
   * 365天以上库龄 比较(startswith)
   */
  private Integer day366Startswith;
  /**
   * 365天以上库龄 比较(endswith)
   */
  private Integer day366Endswith;
  /**
   * 365天以上库龄 比较(isnull)
   */
  private Boolean day366Isnull;
  /**
   * 365天以上库龄 比较(isnotnull)
   */
  private Boolean day366Isnotnull;

  /**
   * 仓库名称(模糊搜索)
   */
  private String wname;

  /**
   * 仓库名称 比较(eq)
   */
  private String wnameEq;
  /**
   * 仓库名称 比较(neq)
   */
  private String wnameNeq;
  /**
   * 仓库名称 比较(gt)
   */
  private String wnameGt;
  /**
   * 仓库名称 比较(gte)
   */
  private String wnameGte;
  /**
   * 仓库名称 比较(lt)
   */
  private String wnameLt;
  /**
   * 仓库名称 比较(lte)
   */
  private String wnameLte;
  /**
   * 仓库名称 比较(contains)
   */
  private String wnameContains;
  /**
   * 仓库名称 比较(notcontains)
   */
  private String wnameNotcontains;
  /**
   * 仓库名称 比较(startswith)
   */
  private String wnameStartswith;
  /**
   * 仓库名称 比较(endswith)
   */
  private String wnameEndswith;
  /**
   * 仓库名称 比较(isnull)
   */
  private Boolean wnameIsnull;
  /**
   * 仓库名称 比较(isnotnull)
   */
  private Boolean wnameIsnotnull;

  /**
   * 仓库名称(精确搜索)
   */
  private List<String> wnameInList;

  /**
   * listing主键
   */
  private Long listingId;

  /**
   * 最小listing主键
   */
  private Long listingIdMin;

  /**
   * 最大listing主键
   */
  private Long listingIdMax;

  /**
   * listing主键 比较(eq)
   */
  private Long listingIdEq;
  /**
   * listing主键 比较(neq)
   */
  private Long listingIdNeq;
  /**
   * listing主键 比较(gt)
   */
  private Long listingIdGt;
  /**
   * listing主键 比较(gte)
   */
  private Long listingIdGte;
  /**
   * listing主键 比较(lt)
   */
  private Long listingIdLt;
  /**
   * listing主键 比较(lte)
   */
  private Long listingIdLte;
  /**
   * listing主键 比较(contains)
   */
  private Long listingIdContains;
  /**
   * listing主键 比较(notcontains)
   */
  private Long listingIdNotcontains;
  /**
   * listing主键 比较(startswith)
   */
  private Long listingIdStartswith;
  /**
   * listing主键 比较(endswith)
   */
  private Long listingIdEndswith;
  /**
   * listing主键 比较(isnull)
   */
  private Boolean listingIdIsnull;
  /**
   * listing主键 比较(isnotnull)
   */
  private Boolean listingIdIsnotnull;

  /**
   * 配送类型(模糊搜索)
   */
  private String fulfillmentChannelType;

  /**
   * 配送类型 比较(eq)
   */
  private String fulfillmentChannelTypeEq;
  /**
   * 配送类型 比较(neq)
   */
  private String fulfillmentChannelTypeNeq;
  /**
   * 配送类型 比较(gt)
   */
  private String fulfillmentChannelTypeGt;
  /**
   * 配送类型 比较(gte)
   */
  private String fulfillmentChannelTypeGte;
  /**
   * 配送类型 比较(lt)
   */
  private String fulfillmentChannelTypeLt;
  /**
   * 配送类型 比较(lte)
   */
  private String fulfillmentChannelTypeLte;
  /**
   * 配送类型 比较(contains)
   */
  private String fulfillmentChannelTypeContains;
  /**
   * 配送类型 比较(notcontains)
   */
  private String fulfillmentChannelTypeNotcontains;
  /**
   * 配送类型 比较(startswith)
   */
  private String fulfillmentChannelTypeStartswith;
  /**
   * 配送类型 比较(endswith)
   */
  private String fulfillmentChannelTypeEndswith;
  /**
   * 配送类型 比较(isnull)
   */
  private Boolean fulfillmentChannelTypeIsnull;
  /**
   * 配送类型 比较(isnotnull)
   */
  private Boolean fulfillmentChannelTypeIsnotnull;

  /**
   * 配送类型(精确搜索)
   */
  private List<String> fulfillmentChannelTypeInList;

  /**
   * 店铺
   */
  private Long sid;

  /**
   * 最小店铺
   */
  private Long sidMin;

  /**
   * 最大店铺
   */
  private Long sidMax;

  /**
   * 店铺 比较(eq)
   */
  private Long sidEq;
  /**
   * 店铺 比较(neq)
   */
  private Long sidNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long sidGt;
  /**
   * 店铺 比较(gte)
   */
  private Long sidGte;
  /**
   * 店铺 比较(lt)
   */
  private Long sidLt;
  /**
   * 店铺 比较(lte)
   */
  private Long sidLte;
  /**
   * 店铺 比较(contains)
   */
  private Long sidContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long sidNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long sidStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long sidEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean sidIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean sidIsnotnull;

  /**
   * 采购成本
   */
  private java.math.BigDecimal cost;

  /**
   * 最小采购成本
   */
  private java.math.BigDecimal costMin;

  /**
   * 最大采购成本
   */
  private java.math.BigDecimal costMax;

  /**
   * 采购成本 比较(eq)
   */
  private java.math.BigDecimal costEq;
  /**
   * 采购成本 比较(neq)
   */
  private java.math.BigDecimal costNeq;
  /**
   * 采购成本 比较(gt)
   */
  private java.math.BigDecimal costGt;
  /**
   * 采购成本 比较(gte)
   */
  private java.math.BigDecimal costGte;
  /**
   * 采购成本 比较(lt)
   */
  private java.math.BigDecimal costLt;
  /**
   * 采购成本 比较(lte)
   */
  private java.math.BigDecimal costLte;
  /**
   * 采购成本 比较(contains)
   */
  private java.math.BigDecimal costContains;
  /**
   * 采购成本 比较(notcontains)
   */
  private java.math.BigDecimal costNotcontains;
  /**
   * 采购成本 比较(startswith)
   */
  private java.math.BigDecimal costStartswith;
  /**
   * 采购成本 比较(endswith)
   */
  private java.math.BigDecimal costEndswith;
  /**
   * 采购成本 比较(isnull)
   */
  private Boolean costIsnull;
  /**
   * 采购成本 比较(isnotnull)
   */
  private Boolean costIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
